// 版权所有2009年围棋作者。版权所有。
// 此源代码的使用受BSD样式的约束
// 可以在许可证文件中找到的许可证。

package walk

import (
	"cmd/compile/internal/base"
	"cmd/compile/internal/ir"
	"cmd/compile/internal/typecheck"
	"cmd/compile/internal/types"
	"cmd/internal/src"
)

// directClosureCall将函数文本的直接调用重写为
// 以闭包变量作为参数传递的普通函数调用。
// 这样可以避免分配闭包对象。
// None
// 如需说明，请调用以下调用：
// None
// func（整数）{
// println（byval）
// 拜里夫++
// }(42)
// None
// 变成：
// None
// func（byval int，&byref*int，a int）{
// println（byval）
// （*&byref）++
// }（拜瓦尔和拜里夫，42岁）
func directClosureCall(n *ir.CallExpr) {
	clo := n.X.(*ir.ClosureExpr)
	clofn := clo.Func

	if ir.IsTrivialClosure(clo) {
		return // 留待处理
	}

	// 如果订单阶段中的wrapGoDefer（）已标记此调用，
	// 避免消除关闭，即使直接调用
	// （需要关闭以简化寄存器ABI）。看见
	// wrapGoDefer了解更多详细信息。
	if n.PreserveClosure {
		return
	}

	// 我们将在输入参数之前插入捕获的变量。
	var params []*types.Field
	var decls []*ir.Name
	for _, v := range clofn.ClosureVars {
		if !v.Byval() {
			// 如果T型v通过引用捕获，
			// 我们引入函数param&v*T
			// v仍然是PAUTOHEAP和&v heapaddr
			// （访问将隐式解除F&v）。

			addr := ir.NewNameAt(clofn.Pos(), typecheck.Lookup("&"+v.Sym().Name))
			addr.Curfn = clofn
			addr.SetType(types.NewPtr(v.Type()))
			v.Heapaddr = addr
			v = addr
		}

		v.Class = ir.PPARAM
		decls = append(decls, v)

		fld := types.NewField(src.NoXPos, v.Sym(), v.Type())
		fld.Nname = v
		params = append(params, fld)
	}

	// f是实际函数的名称。
	f := clofn.Nname
	typ := f.Type()

	// 创建带有参数前缀的新函数类型，以及
	// 然后更新类型和声明。
	typ = types.NewSignature(typ.Pkg(), nil, nil, append(params, typ.Params().FieldSlice()...), typ.Results().FieldSlice())
	f.SetType(typ)
	clofn.Dcl = append(decls, clofn.Dcl...)

	// 重写呼叫。
	n.X = f
	n.Args.Prepend(closureArgs(clo)...)

	// 更新调用表达式的类型。我们需要这样做
	// 因为typecheck为它提供了OCLOSURE的结果类型
	// 节点，但我们只重写了ONAME节点的类型。逻辑上
	// 它们是一样的，但是堆栈偏移可能会改变。
	if typ.NumResults() == 1 {
		n.SetType(typ.Results().Field(0).Type)
	} else {
		n.SetType(typ.Results())
	}

	// 添加到enqueueFunc的闭包。这不再是一个恰当的选择
	// 闭包，但我们可能已经在
	// 函数列表作为一个非平凡的闭包，因此
	// 确保它已编译。
	ir.CurFunc.Closures = append(ir.CurFunc.Closures, clofn)
}

func walkClosure(clo *ir.ClosureExpr, init *ir.Nodes) ir.Node {
	clofn := clo.Func

	// 如果没有闭合变量，不要麻烦包装。
	if ir.IsTrivialClosure(clo) {
		if base.Debug.Closure > 0 {
			base.WarnfAt(clo.Pos(), "closure converted to global")
		}
		return clofn.Nname
	}

	// 闭包不是简单的或直接调用的，因此它将保持闭包状态。
	ir.ClosureDebugRuntimeCheck(clo)
	clofn.SetNeedctxt(true)
	ir.CurFunc.Closures = append(ir.CurFunc.Closures, clofn)

	typ := typecheck.ClosureType(clo)

	clos := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ), nil)
	clos.SetEsc(clo.Esc())
	clos.List = append([]ir.Node{ir.NewUnaryExpr(base.Pos, ir.OCFUNC, clofn.Nname)}, closureArgs(clo)...)

	addr := typecheck.NodAddr(clos)
	addr.SetEsc(clo.Esc())

	// 强制将类型从*struct转换为func类型。
	cfn := typecheck.ConvNop(addr, clo.Type())

	// 要使用的非逃逸温度（如有）。
	if x := clo.Prealloc; x != nil {
		if !types.Identical(typ, x.Type()) {
			panic("closure type does not match order's assigned type")
		}
		addr.Prealloc = x
		clo.Prealloc = nil
	}

	return walkExpr(cfn, init)
}

// closureArgs返回一个表达式片段，该片段可用于
// 初始化给定闭包的自由变量。这些对应
// 与clo.Func.ClosureVars中的变量一一对应，并将
// ONAME节点（如果变量由值捕获）或
// ONAME节点的OADDR（如果没有）。
func closureArgs(clo *ir.ClosureExpr) []ir.Node {
	fn := clo.Func

	args := make([]ir.Node, len(fn.ClosureVars))
	for i, v := range fn.ClosureVars {
		var outer ir.Node
		outer = v.Outer
		if !v.Byval() {
			outer = typecheck.NodAddrAt(fn.Pos(), outer)
		}
		args[i] = typecheck.Expr(outer)
	}
	return args
}

func walkCallPart(n *ir.SelectorExpr, init *ir.Nodes) ir.Node {
	// 以复合文字的形式创建闭包。
	// 对于接收器（x）类型为T的x.M，生成的代码如下所示：
	// None
	// clos=&struct{F uintpttr；rt}{T.M·F，x}
	// None
	// 就像上面提到的那样。

	if n.X.Type().IsInterface() {
		// 现在在nil接口上为方法触发死机。
		// 否则，它会发生在包装器中，并且令人困惑。
		n.X = cheapExpr(n.X, init)
		n.X = walkExpr(n.X, nil)

		tab := typecheck.Expr(ir.NewUnaryExpr(base.Pos, ir.OITAB, n.X))

		c := ir.NewUnaryExpr(base.Pos, ir.OCHECKNIL, tab)
		c.SetTypecheck(1)
		init.Append(c)
	}

	typ := typecheck.PartialCallType(n)

	clos := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ), nil)
	clos.SetEsc(n.Esc())
	clos.List = []ir.Node{ir.NewUnaryExpr(base.Pos, ir.OCFUNC, typecheck.MethodValueWrapper(n).Nname), n.X}

	addr := typecheck.NodAddr(clos)
	addr.SetEsc(n.Esc())

	// 强制将类型从*struct转换为func类型。
	cfn := typecheck.ConvNop(addr, n.Type())

	// 要使用的非逃逸温度（如有）。
	if x := n.Prealloc; x != nil {
		if !types.Identical(typ, x.Type()) {
			panic("partial call type does not match order's assigned type")
		}
		addr.Prealloc = x
		n.Prealloc = nil
	}

	return walkExpr(cfn, init)
}
